/*
 Práctica 1 asignatura Desarrollo Aplicaciones Móviles

    -Informática-

Integrantes:  Esperanza González de la Mora & Félix López Garcinuño & José Miguel Bilbao Navas
 */

package capa_datos;

import capa_dominio.*;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordStoreException;
import java.io.*;
import java.util.Date;
import javax.microedition.rms.RecordComparator;
//import javax.microedition.rms.RecordFilter;

public class DatosRS implements RecordComparator{
    private RecordStore rsgastos;
    private RecordStore rsmonedas;
    private RecordStore rsdescripciones;

    public DatosRS(){
        //No vamos abrir los RecordStore en el método de creación para llevar un control
        //de la apertura-cierre en cada submétodo

        //Añadimos un recordListener por si se modifica, añade o borra un registro de nuestros RecordStores
        //Lo introducimos en otra clase a parte para desacoplar la capa de datos
        //rsgastos.addRecordListener(new ControladorActualizacion());
    }

    public void borraGastos(){
         try{
             RecordStore.deleteRecordStore("rsgastos");
         }catch (RecordStoreException e){
             System.out.println("Error al eliminar el Record Store Gastos");
         }        
    }
    
    public void borraMonedas(){
        try{
             RecordStore.deleteRecordStore("rsmonedas");
         }catch (RecordStoreException e){
             System.out.println("Error al eliminar el Record Store Monedas");
         }
    }

    public void borraDescripciones(){
        try{
             RecordStore.deleteRecordStore("rsdescripciones");
         }catch (RecordStoreException e){
             System.out.println("Error al eliminar el Record Store Descripciones");
         }
    }

    public String[] leeDatos(String rs){
        String[] devuelve=null;//Contenedor de los gastos del RecordStore gastos        
        ByteArrayInputStream bais;
        DataInputStream dis;
        int j=0; //Contador de registros. El índice de vectores empieza en 0


       if (rs.equals("gastos")){ //Leemos RecordStore de Gastos

           System.out.println("Se ha metido en lectura!");
            //abrimos RecordStore de gastos
         try{
           rsgastos=rsgastos.openRecordStore("rsgastos", true);
           //rsgastos.openRecordStore("rsgastos", true, AUTHMODE_PRIVATE, false);

           System.out.println("Numero de records en rsgastos:"+rsgastos.getNumRecords());

           if (rsgastos.getNumRecords()==0){
               devuelve=new String[0];
               //return gastos;
           }else{
                //Hacemos uso de interfaz RecordEnumeration
                 RecordEnumeration re=rsgastos.enumerateRecords(null,null,false);                 
                 devuelve=new String[rsgastos.getNumRecords()*3];//Tamaño de cada registro:3
                 
                try{
                System.out.println("Llega hasta lecutra propia de record");

                //Iniciamos posición de RecordEnumeration
                re.reset();
                while (re.hasNextElement()){

                         System.out.println("tiene sig registro?"+re.hasNextElement());
                         byte[] registro=re.nextRecord();

                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);
                                                 
                         devuelve[j]=dis.readUTF();
                         System.out.println(devuelve[j]);
                         devuelve[j+1]=dis.readUTF();
                         System.out.println(devuelve[j+1]);
                         devuelve[j+2]=dis.readUTF();
                         System.out.println(devuelve[j+2]);


                         bais.reset();
                         j=j+3;
                         bais.close();
                         dis.close();
                         registro=null;
                }
               
                }
                catch (Exception e){
                    System.out.println("Error al leer los registros");
                }
         }//fin else
         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore Gastos");
         }
         //Cerramos RecordStore Gastos
         try{
         rsgastos.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Gastos");
         }

         /*
         //Para pruebaaaaaaaaaaaaaaaaa
         try{
             RecordStore.deleteRecordStore("rsgastos");
         }catch (RecordStoreException e){
             System.out.println("Error al eliminar el Record Store Gastos");
         }
         */

       }else if (rs.equals("monedas")){
           try{
           rsmonedas=rsmonedas.openRecordStore("rsmonedas", true);
           if (rsmonedas.getNumRecords()==0){
               devuelve=new String[0];

           }else{
                System.out.println("Entramos en lectura de rsmonedas,Numero de records en rsmonedas:"+rsmonedas.getNumRecords());
                //Hacemos uso de interfaz RecordEnumeration
                 RecordEnumeration re=rsmonedas.enumerateRecords(null,null,false);
                 devuelve=new String[rsmonedas.getNumRecords()*(rsmonedas.getNumRecords()+2)];//Tamaño de cada registro:2 campos + fila de tabla de divisas cruzadas: nº de divisas que hay

                try{
                while (re.hasNextElement()){

                         byte[] registro=re.nextRecord();

                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);

                         System.out.println("Tamaño registro:"+registro.length);
                         System.out.println(new String(registro));

                         devuelve[j]=dis.readUTF();//Lee Definicion de moneda
                         System.out.println("Lee descripcion moneda:"+devuelve[j]);
                         devuelve[j+1]=dis.readUTF();
                         System.out.println("Lee siglas moneda:"+devuelve[j+1]);//Lee Sigla de moneda
                         


                         for (int r=2; r<=rsmonedas.getNumRecords()+2-1;r++){//Lee fila de tabla de divisas
                             devuelve[j+r]=dis.readUTF();
                             System.out.println("Lee divisas moneda:"+devuelve[j+r]);
                         }


                                                
                         bais.reset();
                         j=j+rsmonedas.getNumRecords()+2;
                         bais.close();
                         dis.close();
                         registro=null;
                }

                }
                catch (Exception e){
                    System.out.println("Error al leer los registros");
                }
         }//fin else
         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore Monedas");
         }
         //Cerramos RecordStore Monedas
         try{
         rsmonedas.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Monedas");
         }
         /*
         //Para pruebaaaaaaaaaaaaaaaaa
         try{
             RecordStore.deleteRecordStore("rsmonedas");
         }catch (RecordStoreException e){
             System.out.println("Error al eliminar el Record Store Monedas");
         }
         */
       }      
        return devuelve;

    }

     public void escribeGastos(String[] gastos){
        byte[] registro;
        ByteArrayOutputStream baos;
        DataOutputStream dos;

        try{
            rsgastos=RecordStore.openRecordStore("rsgastos",true);
        }catch (RecordStoreException e){
            System.out.println("Error al abrir el Record Store Gastos");
        }

        try{
                                    
            int i=0;
            while (i<=gastos.length-1){
                baos=new ByteArrayOutputStream();
                dos=new DataOutputStream(baos);
                registro=new byte[75];

                dos.writeUTF(gastos[i]);
                System.out.println(dos);
                dos.writeUTF(gastos[i+1]);
                System.out.println(dos);
                dos.writeUTF(gastos[i+2]);
                System.out.println(dos);
                
                dos.flush();
                System.out.println(new String(registro)+"holaholahola");
                registro=baos.toByteArray();
                System.out.println(new String(registro));
                rsgastos.addRecord(registro,0,registro.length);
                i=i+3;
                System.out.println(rsgastos.getRecordSize(1));

                baos.close();
                dos.close();
                registro=null;

            }
            System.out.println("llega");
            
        }
        catch (Exception e){//Excepción más general para ser capturada
            System.out.println("Error al insertar registro");
        }

        try{
            rsgastos.closeRecordStore();
        }catch (RecordStoreException e){
            System.out.println("Error al cerrar el RecordStore Gastos");
        }
       
    }

      public void escribeMonedas(String[] monedas){
        byte[] registro;
        ByteArrayOutputStream baos;
        DataOutputStream dos;

        try{
            rsmonedas=RecordStore.openRecordStore("rsmonedas",true);
        }catch (RecordStoreException e){
            System.out.println("Error al abrir el Record Store Monedas");
        }

        try{
            
            System.out.println("Numero de records en rsmonedas:"+rsmonedas.getNumRecords());

            //Caluculo número de registros por tamaño de array
            double n=(-2+Math.sqrt(4+4*monedas.length))/2;
            System.out.println("Número de n, número de registros calculados por array:"+String.valueOf(n));
            //Pasamos a entero redondeando hacia abajo
            int nentero=(int)n;
            int i=0;
            while (i<=monedas.length-1){
                baos=new ByteArrayOutputStream();
                dos=new DataOutputStream(baos);
                registro=new byte[75];

                dos.writeUTF(monedas[i]);//Escribe descripcion moneda
                dos.writeUTF(monedas[i+1]);//Escribe sigla moneda
                System.out.println("Descripcion moneda:"+monedas[i]);
                System.out.println("Sigla moneda:"+monedas[i+1]);
                
                for (int r=2;r<=nentero+2-1;r++ ){//Escribimos fila de tabla de divisas cruzadas
                    dos.writeUTF(monedas[i+r]);
                    System.out.println("Valor tabla de divisas:"+monedas[i+r]);
                }
                
                dos.flush();
                registro=baos.toByteArray();
                System.out.println(new String(registro));
                rsmonedas.addRecord(registro,0,registro.length);
                i=i+2+nentero;//Tamaño de registro en rsmonedas:2 campos+ nº de monedas que tengo en la tabla de divisas

                baos.close();
                dos.close();                
                registro=null;

            }
            System.out.println("llega");

        }
        catch (Exception e){//Excepción más general para ser capturada
            System.out.println("Error al insertar registro");
        }

        try{
            rsmonedas.closeRecordStore();
        }catch (RecordStoreException e){
            System.out.println("Error al cerrar el RecordStore Monedas");
        }

    }

      public void escribeDescripcionMonedas(String listatodaslasmonedas){
          //A partir de una cadena con todas las monedas del mundo y sus descripciones
          //creamos un registro rsdescripciones que contiene la descripcion y sigla de moneda

        byte[] registro;
        ByteArrayOutputStream baos;
        DataOutputStream dos;

        try{
            rsdescripciones=RecordStore.openRecordStore("rsdescripciones",true);
        }catch (RecordStoreException e){
            System.out.println("Error al abrir el Record Store Descripciones");
        }

        System.out.println("Entra en escritura de Descripciones!!!!");
        try{

            int iniciodes=0;
            int leido=0;
            int i=0;
            System.out.println("Tamaño listatodaslasmonedas:"+listatodaslasmonedas.length());
            int caracterescadenatotal=listatodaslasmonedas.length();
            while (i<=caracterescadenatotal-1){

                baos=new ByteArrayOutputStream();
                dos=new DataOutputStream(baos);
                registro=new byte[75];

                System.out.println(listatodaslasmonedas.substring(0,listatodaslasmonedas.indexOf("(")));
                System.out.println(listatodaslasmonedas.substring(listatodaslasmonedas.indexOf("(")+1, listatodaslasmonedas.indexOf("),")));

                String cadenadescripcion=listatodaslasmonedas.substring(0,listatodaslasmonedas.indexOf("("));
                String cadenasigla=listatodaslasmonedas.substring(listatodaslasmonedas.indexOf("(")+1, listatodaslasmonedas.indexOf("),"));

                //posicion hasta donde he leido
                iniciodes=listatodaslasmonedas.indexOf("),")+2;

                //Cuento caracteres que he leido
                leido=iniciodes+1;

                //Me quedo con lo que queda por leer
                listatodaslasmonedas=listatodaslasmonedas.substring(iniciodes);
                System.out.println(listatodaslasmonedas);
                
                System.out.println("iniciodes"+iniciodes);
                i=i+leido;//contador de lectura de cadena completa, posiciones leidas
                iniciodes=0;
                System.out.println("i:"+i);

                dos.writeUTF(cadenadescripcion);
                System.out.println("Esta es la cadena descripción a introducir rsdescripcion:"+cadenadescripcion);
                dos.writeUTF(cadenasigla);
                System.out.println("Esta es la cadena sigla a introducir en rsdescripcion:"+cadenasigla);

                dos.flush();
                registro=baos.toByteArray();
                rsdescripciones.addRecord(registro,0,registro.length);

                baos.close();
                dos.close();
                registro=null;
                

            }

            System.out.println("Número de registros en rsdescripciones:"+rsdescripciones.getNumRecords());
        }
        catch (Exception e){//Excepción más general para ser capturada
            System.out.println("Error al insertar registro");
        }

        try{
            rsdescripciones.closeRecordStore();
        }catch (RecordStoreException e){
            System.out.println("Error al cerrar el RecordStore Descripciones");
        }

        System.out.println("--------------------Terminó escritura de rsdescripciones--------------------");
      }

      public int compare(byte[] rec1, byte[] rec2) {//Método general de comparación por RecordComparator
      //Hace comparación de dos arrays de bytes por medio de cadenas de texto
      //No hace bien la comparación de fechas mediante cadenas de texto
        ByteArrayInputStream bais;
        DataInputStream dis;
        String cad1, cad2;

        try{
            //Utilizo ByteArrayInputStream y DataInputStream para utilizar readUTF
            //y extraer cadenas
            bais=new ByteArrayInputStream(rec1);
            dis=new DataInputStream(bais);
            cad1=dis.readUTF();
            bais.close();
            dis.close();
            bais=new ByteArrayInputStream(rec2);
            dis=new DataInputStream(bais);
            cad2=dis.readUTF();
            bais.close();
            dis.close();
            bais.reset();

            //Hago comparación por cadenas de texto
            int resultado=cad1.compareTo(cad2);

            System.out.println("cad1:"+cad1+"cad2:"+cad2+"resultado:"+resultado);

            if(resultado==0){
                return RecordComparator.EQUIVALENT;
            }else if (resultado<0){
                return RecordComparator.PRECEDES;
            }else{
                return RecordComparator.FOLLOWS;
            }

         }catch (Exception e) {
             return RecordComparator.EQUIVALENT;
         }
      }
      
      public int compareDates(byte[] rec1, byte[] rec2){
        ByteArrayInputStream bais;
        DataInputStream dis;
        String cad1, cad2;
        Date cadate1, cadate2;//Tratamiento de la fecha por milisegundos
        SuperDate auxcadate1,auxcadate2;
        long ldate1,ldate2;//contenedor de resultados de milisegundos
        //JamaME no tiene en el paquete text la clase SimpleFormatDate
        //Usamos nuestra propia clase Date: SuperDate para manejar con mayor
        //facilidad las fechas
        
       
        try{
            //Utilizo ByteArrayInputStream y DataInputStream para utilizar readUTF
            //y extraer cadenas
            bais=new ByteArrayInputStream(rec1);
            dis=new DataInputStream(bais);
            cad1=dis.readUTF();
            System.out.println("Cad1:"+cad1);
            cad1=cad1+"-00:00:00.0";//Formato de 21 caracteres para usar parseDate de SuperDate
            cadate1=new Date(0);
            System.out.println(cadate1.toString());
            auxcadate1=new SuperDate();
            System.out.println(auxcadate1.toString());
            cadate1=auxcadate1.parseDate(cad1);//Convertimos a Date
            System.out.println(cadate1.toString());
            //bais.close();
            //dis.close();
            bais.reset();

            
            bais=new ByteArrayInputStream(rec2);
            dis=new DataInputStream(bais);
            cad2=dis.readUTF();
            System.out.println("Cad2:"+cad2);
            cad2=cad2+"-00:00:00.0";//Formato de 21 caracteres para usar parseDate de SuperDate
            cadate2=new Date(0);
            auxcadate2=new SuperDate();
            cadate2=auxcadate2.parseDate(cad2);//Convertimos a Date
            bais.close();
            dis.close();
            bais.reset();

            //Conseguimos milisegundos de las fechas
            ldate1=cadate1.getTime();
            ldate2=cadate2.getTime();
            System.out.println("long de milisegundos de cadate1:"+cadate1);
            System.out.println("long de milisegundos de cadate2:"+cadate2);


            if(ldate1==ldate2){
                System.out.println("Resultado comparacion:0");
                return 0;
            }else if (ldate1<ldate2){
                System.out.println("Resultado comparacion:-1");
                return -1;
            }else{
                System.out.println("Resultado comparacion:1");
                return 1;
            }

         }catch (Exception e) {
             return RecordComparator.EQUIVALENT;
         }
          
      }



      public String[] ordenacionTemporalDescendente (String[] lista){          
          String[] listagastos;
          ByteArrayOutputStream baos;
          DataOutputStream dos;
          byte[] reg1,reg2;//registros para ordenación 
          String[] itemaux=new String[3];//Array de cadenas como auxiliar en ordenación
          int i,pass;//contadores para ordenación
          

          listagastos=lista;

          //Aplicamos método de Búsqueda por prioridad de menores
          try{
              for(pass=0; pass< listagastos.length;pass=pass+3){
                  for(i=0; i<listagastos.length;i=i+3){

                      baos=new ByteArrayOutputStream();
                      dos=new DataOutputStream(baos);
                      dos.writeUTF(lista[pass]);
                      dos.flush();
                      reg1=baos.toByteArray();
                      baos.reset();
                      baos.close();
                      dos.close();                      

                      baos=new ByteArrayOutputStream();
                      dos=new DataOutputStream(baos);
                      dos.writeUTF(lista[i]);                      
                      reg2=baos.toByteArray();
                      baos.reset();
                      baos.close();
                      dos.close();
                      
                      
                      if(pass<i){
                            if(this.compareDates(reg1,reg2)==RecordComparator.FOLLOWS){
                                System.out.println("Resultado RecordCompator.FOLLOWS"+RecordComparator.FOLLOWS);
                                 itemaux[0]=listagastos[i];
                                 itemaux[1]=listagastos[i+1];
                                 itemaux[2]=listagastos[i+2];

                                 listagastos[i]=listagastos[pass];
                                 listagastos[i+1]=listagastos[pass+1];
                                 listagastos[i+2]=listagastos[pass+2];

                                 listagastos[pass]=itemaux[0];
                                 listagastos[pass+1]=itemaux[1];
                                 listagastos[pass+2]=itemaux[2];
                            }

                      }
                  }
              }

          }catch (Exception e){
              System.out.println("Ha fallado el Método de ordenacionTemporalDescendente");
          }

          return listagastos;

      }

      public String[] ordenacionAscendenteGastos(String[] lista){
          String[] listagastos;
          double gasto1,gasto2;
          String[] itemaux=new String[3];//Array de cadenas como auxiliar en ordenación
          int i,pass;//contadores para ordenación


          listagastos=lista;

          //Aplicamos método de Búsqueda por prioridad de máximos
          
              for(pass=0; pass< listagastos.length;pass=pass+3){
                  for(i=0; i<listagastos.length;i=i+3){

                      
                      gasto1=Double.parseDouble(listagastos[pass+2].substring(0, listagastos[pass+2].indexOf(" ")));
                      gasto2=Double.parseDouble(listagastos[i+2].substring(0, listagastos[i+2].indexOf(" ")));
                      System.out.println("Ver gasto1:"+gasto1);
                      System.out.println("Ver gasto2:"+gasto2);

                      if(pass<i){
                            if(gasto1<gasto2){

                                 itemaux[0]=listagastos[i];
                                 itemaux[1]=listagastos[i+1];
                                 itemaux[2]=listagastos[i+2];

                                 listagastos[i]=listagastos[pass];
                                 listagastos[i+1]=listagastos[pass+1];
                                 listagastos[i+2]=listagastos[pass+2];

                                 listagastos[pass]=itemaux[0];
                                 listagastos[pass+1]=itemaux[1];
                                 listagastos[pass+2]=itemaux[2];


                            }

                      }
                  }
              }

          

          //Comprobación
          System.out.println("Comprobación de listagastos ordenados de forma ascendente en gastos");
          for (int k=0; k<=listagastos.length-1;k++){
              System.out.println(listagastos[k]);
          }

          return listagastos;


      }

      public String[] ordenacionTemporalAscendente (String[] lista){
          String[] listagastos;
          ByteArrayOutputStream baos;
          DataOutputStream dos;
          byte[] reg1,reg2;//registros para ordenación
          String[] itemaux=new String[3];//Array de cadenas como auxiliar en ordenación
          int i,pass;//contadores para ordenación


          listagastos=lista;

          //Aplicamos método de Búsqueda por prioridad de máximos
          try{
              for(pass=0; pass< listagastos.length;pass=pass+3){
                  for(i=0; i<listagastos.length;i=i+3){

                      baos=new ByteArrayOutputStream();
                      dos=new DataOutputStream(baos);
                      dos.writeUTF(lista[pass]);
                      dos.flush();
                      reg1=baos.toByteArray();
                      baos.reset();
                      baos.close();
                      dos.close();

                      baos=new ByteArrayOutputStream();
                      dos=new DataOutputStream(baos);
                      dos.writeUTF(lista[i]);
                      reg2=baos.toByteArray();
                      baos.reset();
                      baos.close();
                      dos.close();


                      if(pass<i){
                            if(this.compareDates(reg1,reg2)==RecordComparator.PRECEDES){
                                System.out.println("Resultado RecordCompator.FOLLOWS"+RecordComparator.FOLLOWS);
                                 itemaux[0]=listagastos[i];
                                 itemaux[1]=listagastos[i+1];
                                 itemaux[2]=listagastos[i+2];

                                 listagastos[i]=listagastos[pass];
                                 listagastos[i+1]=listagastos[pass+1];
                                 listagastos[i+2]=listagastos[pass+2];

                                 listagastos[pass]=itemaux[0];
                                 listagastos[pass+1]=itemaux[1];
                                 listagastos[pass+2]=itemaux[2];

                            }

                      }
                  }
              }

          }catch (Exception e){
              System.out.println("Ha fallado el Método de ordenacionTemporalDescendente");
          }

          return listagastos;

     }

     public String[] dameRegistroMonedas (int posicion){
         //Retorna en modo cadena el registro de posicion i del record store de monedas
         byte[] registro;
         ByteArrayInputStream bais;
         DataInputStream dis;
         String[] registrocadena=null;
        
         try{
           rsmonedas=rsmonedas.openRecordStore("rsmonedas", true);
          
                try{
                         registrocadena=new String[rsmonedas.getNumRecords()+2];//Tamaño:número de registros en el rsmonedas (número en tabla divisas)+2 (descrip y siglas)
                         System.out.println("Vemos cuantos registros hay en monedas"+rsmonedas.getNumRecords());
                         
                         //Creamos registro con tamaño el del registro correspondiente
                         //Hay que tener en cuenta que el índice de los RecordStore empiezan en 1 y no en 0
                         //por eso la posición hay que añadirle uno
                         registro=new byte[rsmonedas.getRecordSize(posicion+1)];

                         registro=rsmonedas.getRecord(posicion+1);

                         //Leemos registro
                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);

                         //Leemos descripcion de moneda
                         registrocadena[0]=dis.readUTF();
                         //Leemos siglas de moneda
                         registrocadena[1]=dis.readUTF();
                         for (int r=2; r<=rsmonedas.getNumRecords()+2-1;r++){//Lee fila de tabla de divisas
                             registrocadena[r]=dis.readUTF();
                         }
                         

                         //bais.reset();
                         bais.close();
                         dis.close();
                         registro=null;


                }
                catch (Exception e){
                    System.out.println("Error al leer los registros");
                }

         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore Monedas");
         }
         //Cerramos RecordStore Monedas
         try{
         rsmonedas.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Monedas");
         }
         return registrocadena;

     }

     public int dameIndiceMoneda(String siglamoneda){
         //Retorna el índice de posición de la moneda en el RecordStore
         String[] contenedorregistro=null;
         ByteArrayInputStream bais;
         DataInputStream dis;
         int indiceresultado=0;
         int j=0;//contador para array
         int ind=0;//contador de vueltas y guia de índice
        
         try{
           rsmonedas=rsmonedas.openRecordStore("rsmonedas", true);
           if (rsmonedas.getNumRecords()==0){
               indiceresultado=0;

           }else{
                //Hacemos uso de interfaz RecordEnumeration
                 RecordEnumeration re=rsmonedas.enumerateRecords(null,null,false);
                 contenedorregistro=new String[rsmonedas.getNumRecords()*(rsmonedas.getNumRecords()+2)];//Tamaño total del RecordStore x nº de registros+2
                try{
                while (re.hasNextElement()){

                         byte[] registro=re.nextRecord();

                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);

                         contenedorregistro[j]=dis.readUTF();//Ha leido descripcion
                         contenedorregistro[j+1]=dis.readUTF();//Ha leido siglas
                         for (int r=2; r<=rsmonedas.getNumRecords()+2-1;r++){//Ha leido fila de tabla de divisas
                             contenedorregistro[j+r]=dis.readUTF();
                         }
                         
                         if (contenedorregistro[j+1].equalsIgnoreCase(siglamoneda)){
                             //Devuelve el índice siguiente porque para un RecordStore
                             //los índices empiezan por 1 y en el ChoiceGroup por 0
                             
                             indiceresultado=ind+1;
                             System.out.println("Cuantos registros hay en rsmonedas?:"+rsmonedas.getNumRecords());
                             System.out.println("Valor de siglas contenedorregistro"+contenedorregistro[j+1]);
                             System.out.println("Resultado indiceresultado:"+indiceresultado);
                         }
                         bais.reset();
                         j=j+rsmonedas.getNumRecords()+2;
                         bais.close();
                         dis.close();
                         registro=null;
                         ind++;
                }

                }
                catch (Exception e){
                    System.out.println("Error al leer los registros");
                }
         }//fin else
         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore Monedas");
         }
         //Cerramos RecordStore Monedas
         try{
         rsmonedas.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Monedas");
         }
         return indiceresultado;
     }

     public int buscaPosicionGasto(String[] datosgasto){
         //Busca la posicion en el RecordStore de este gasto
         
        String[] devuelve=null;//Contenedor de los gastos del RecordStore gastos       
        ByteArrayInputStream bais;
        DataInputStream dis;
        int j=0; //Contador de registros. El índice de vectores empieza en 0
        int posicion=0;//indice a devolver
        int i=0;//contador de vueltas de lectura del recordStore gastos

          try{
           rsgastos=rsgastos.openRecordStore("rsgastos", true);
           
           System.out.println("Numero de records:"+rsgastos.getNumRecords());
           if (rsgastos.getNumRecords()==0){
               posicion=0;
           }else{
                //Hacemos uso de interfaz RecordEnumeration
                 RecordEnumeration re=rsgastos.enumerateRecords(null,null,false);
                 devuelve=new String[rsgastos.getNumRecords()*3];//Tamaño de cada registro:3
               
                try{              

                //Iniciamos posición de RecordEnumeration
                re.reset();
                while (re.hasNextElement()){
                         i=i+1;//Cuenta los registros leidos=indice de registro leido
                         byte[] registro=re.nextRecord();

                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);                       
                                                  
                         devuelve[j]=dis.readUTF();                         
                         devuelve[j+1]=dis.readUTF();                         
                         devuelve[j+2]=dis.readUTF();

                         System.out.println("Lectura de gastos, devuelve:"+devuelve[j]+devuelve[j+1]+devuelve[j+2]);
                         System.out.println("Comparamos con datosgasto:"+datosgasto[0]+datosgasto[1]+datosgasto[2]);
                         boolean resultadito=devuelve[j].equalsIgnoreCase(datosgasto[0]) && devuelve[j+1].equalsIgnoreCase(datosgasto[1]) && devuelve[j+2].equalsIgnoreCase(datosgasto[2]);
                         System.out.println("Resultado de comparacion:"+resultadito);
                         
                         if (devuelve[j].equals(datosgasto[0]) && devuelve[j+1].equals(datosgasto[1]) && devuelve[j+2].equals(datosgasto[2])){
                             //Los indices en el RecordStore empiezan por 1
                             posicion=i;
                         }
                         
                         bais.reset();
                         j=j+3;
                         bais.close();
                         dis.close();
                         registro=null;
                         

                }
                
                }
                catch (Exception e){
                    System.out.println("Error al leer los registros");
                }
         }//fin else
         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore Gastos");
         }
         //Cerramos RecordStore Gastos
         try{
         rsgastos.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Gastos");
         }       
         
         return posicion;
     }

     public void cambiaGasto(String[] datosgastos, int posicionrs){
        //Cambia valores del registro con posicion posicionrs del RecordStore
        byte[] registro;
        ByteArrayOutputStream baos;
        DataOutputStream dos;

        try{
            rsgastos=RecordStore.openRecordStore("rsgastos",true);
        }catch (RecordStoreException e){
            System.out.println("Error al abrir el Record Store Gastos");
        }

        try{

                baos=new ByteArrayOutputStream();
                dos=new DataOutputStream(baos);
                registro=new byte[75];

                dos.writeUTF(datosgastos[0]);
                dos.writeUTF(datosgastos[1]);
                dos.writeUTF(datosgastos[2]);

                dos.flush();

                registro=baos.toByteArray();
                rsgastos.setRecord(posicionrs, registro, 0, registro.length);

                baos.close();
                dos.close();
                registro=null;

        }
        catch (Exception e){//Excepción más general para ser capturada
            System.out.println("Error al insertar registro");
        }

        try{
            rsgastos.closeRecordStore();
        }catch (RecordStoreException e){
            System.out.println("Error al cerrar el RecordStore Gastos");
        }


     }

     public void borraGasto(int posicion){
         //Borra el gasto del RecordStore mediante el índice (identificador) de posicion

        try{
            rsgastos=RecordStore.openRecordStore("rsgastos",true);
        }catch (RecordStoreException e){
            System.out.println("Error al abrir el Record Store Gastos");
        }
        try{
        rsgastos.deleteRecord(posicion);
        }catch (RecordStoreException e){
             System.out.println("Error al borrar el registro de gastos por la posicion indicada");
        }

        try{
            rsgastos.closeRecordStore();
        }catch (RecordStoreException e){
            System.out.println("Error al cerrar el RecordStore Gastos");
        }

     }

     public void introducirNuevaMoneda(String siglasnuevamoneda, String descripcionnuevamoneda, String[] filadivisas, String[] columnadivisas){
         //A partir de las siglas de NuevaMoneda aceptada, descripcion, fila y columna de la tabla de divisas cruzadas
         //introducimos nueva moneda en el RecordStore de monedas
         String[] listamonedas;
         String[] nuevalistamonedas;
         int indicecolumna=0;//contador de indice columna
         int indicenuevalista=0;//indice de registros ya almacenados

         //Extraemos lista de monedas
         listamonedas=this.leeDatos("monedas");

         //Caluculo número de registros por tamaño de array de listamonedas
          double n=(-2+Math.sqrt(4+4*listamonedas.length))/2;

         //Pasamos a entero redondeando hacia abajo
         int nentero=(int)n;

         //Creamos nuevalistamonedas
         nuevalistamonedas=new String[(2+nentero+1)*(nentero+1)];


         //Metemos en nuevalistamonedas la lista de monedas ya almacenada junto con la columna de divisas de la nueva moneda
         for (int j=0; j<=listamonedas.length-1;j=j+nentero+2){
             nuevalistamonedas[j+indicenuevalista]=listamonedas[j];
             System.out.println("Descripcion nuevalista[j+indicenuevalista]:"+nuevalistamonedas[j+indicenuevalista]);
             nuevalistamonedas[j+1+indicenuevalista]=listamonedas[j+1];//metemos siglas de moneda
             System.out.println("Siglas nuevalista[j+1+indicenuevalista]:"+nuevalistamonedas[j+1+indicenuevalista]);
             for (int r=2; r<=nentero+2-1;r++){//metemos fila de divisas ya almacenadas
                     nuevalistamonedas[j+r+indicenuevalista]=listamonedas[r+j];
                     System.out.println("Nuevalistamonedas[j+r+indicenuevalista]:"+nuevalistamonedas[j+r+indicenuevalista]);
                     System.out.println("Valor de r:"+r);
             }
             System.out.println("Valor de j+2+nentero+indicecolumna:"+j+2+nentero+indicecolumna);
             System.out.println("columnadivisas[indicecolumna]:"+columnadivisas[indicecolumna]);             
             nuevalistamonedas[j+2+nentero+indicecolumna]=columnadivisas[indicecolumna];
             indicecolumna++;
             indicenuevalista++;
         }
       

         //Metemos en nuevalistamonedas la fila de nuestra nueva moneda con la fila nueva su correspondiente cambio de divisas
         nuevalistamonedas[listamonedas.length+nentero]=descripcionnuevamoneda;
         System.out.println("Añadimos nueva descripcion nuevalistamonedas[listamonedas.length+nentero]:"+nuevalistamonedas[listamonedas.length+nentero]);
         nuevalistamonedas[listamonedas.length+nentero+1]=siglasnuevamoneda;
         System.out.println("Añadimos nueva sigla nuevalistamonedas[listamonedas.length+nentero+1]:"+nuevalistamonedas[listamonedas.length+nentero+1]);
         for (int s=0;s<=filadivisas.length-1;s++){
             nuevalistamonedas[listamonedas.length+nentero+1+s+1]=filadivisas[s];
             System.out.println("Añadimos nueva fila de tabla de divisas de nueva moneda:"+nuevalistamonedas[listamonedas.length+nentero+1+s+1]);
         }

         //Comoprobación columnadivisas
         System.out.println("Comprobacion columnadivisas");
         for (int t=0; t<=columnadivisas.length-1;t++){             
             System.out.println(columnadivisas[t]);
         }

         //Comprobación nuevalistgamonedas
         System.out.println("Comprobacion nuevalistamonedas");
         for (int t=0; t<=nuevalistamonedas.length-1;t++){             
             System.out.println(nuevalistamonedas[t]);
         }
         
         //Borramos al RecordStore monedas para resetar
         this.borraMonedas();

         //Escribimos el RecordStore actualizado
         this.escribeMonedas(nuevalistamonedas);

     }

     public String[] extraeDivisasRespectoMR(String monedareferencia){
         //Extrae las divisas de la tabla de divisas cruzadas respecto a la MR
         String[] divisasMR;

         System.out.println(monedareferencia);
         int posicion=this.dameIndiceMoneda(monedareferencia)-1;
         String[] registroenteroMR=this.dameRegistroMonedas(posicion);

         //Comprobación de registroenteroMR
         System.out.println("Comprobación de registroenteroMR");
         for(int s=0;s<=registroenteroMR.length-1;s++){
             System.out.println(registroenteroMR[s]);
         }

         divisasMR=new String[registroenteroMR.length-2];//tamaño del registro MR-2 (campo:descripcion y siglas)

         int j=0;
         for (int i=2;i<=registroenteroMR.length-1;i++){//A partir de la posición 2 están las divisas

             divisasMR[j]=registroenteroMR[i];
             System.out.println("Valor de tabla divisas del MR:"+divisasMR[j]);
             j++;
         }

          //Comprobación de divisasMR
         System.out.println("Comprobación de divisasMR");
         for(int s=0;s<=divisasMR.length-1;s++){
             System.out.println(divisasMR[s]);
         }

         return divisasMR;
     }

     public String buscaDescripcionMoneda(String siglamoneda){
         //Busca por sigla de moneda en el rsdescripciones la descripción adjunta
         //Retorna vacío si no lo ha encontrado
         //byte[] registro;
         ByteArrayInputStream bais;
         DataInputStream dis;
         String[] registrocadena;
         String descripcionmoneda="";

         try{
           rsdescripciones=rsdescripciones.openRecordStore("rsdescripciones", true);
           System.out.println("------------------Entra en buscar descripcion moneda!!!!!!--------------------------");
           System.out.println("Número de registros en rsdescripciones:"+rsdescripciones.getNumRecords());


                //Hacemos uso de interfaz RecordEnumeration
                RecordEnumeration re=rsdescripciones.enumerateRecords(null,null,false);
                registrocadena=new String[2];

                try{

                //Iniciamos posición de RecordEnumeration
                re.reset();
                while (re.hasNextElement()){

                         System.out.println("tiene sig registro?"+re.hasNextElement());
                         byte[] registro=re.nextRecord();

                         bais=new ByteArrayInputStream(registro);
                         dis=new DataInputStream(bais);

                         //Leemos descripcion de moneda
                         registrocadena[0]=dis.readUTF();
                         System.out.println(registrocadena[0]);
                         //Leemos siglas de moneda
                         registrocadena[1]=dis.readUTF();
                         System.out.println(registrocadena[1]);

                         System.out.println(registrocadena[1]);
                         System.out.println(siglamoneda);

                         if(registrocadena[1].equals(siglamoneda)){
                             descripcionmoneda=registrocadena[0];
                         }

                         bais.reset();
                         bais.close();
                         dis.close();
                         registro=null;
                }

           
                } catch (Exception e) {
                    System.out.println("Error al leer los registros");
                }

         }
         catch (RecordStoreException e){
               System.out.println("Error al abrir RecordStore descripciones");
         }
         //Cerramos RecordStore Descripciones
         try{
         rsdescripciones.closeRecordStore();
         }catch (RecordStoreException e){
             System.out.println("Error al cerrar RecordStore Descripciones");
         }
         return descripcionmoneda;
    }

}
